#include "BulletDynamics/ConstraintSolver/btHingeConstraint.h"
#ifdef __cplusplus
extern "C" {
#endif
btHingeConstraintFloatData* bullet_NewbtHingeConstraintFloatData(){
	btHingeConstraintFloatData* wrap_out = new btHingeConstraintFloatData();
	return wrap_out;
}

int bullet_btHingeConstraintFloatData_GetFieldOfM_angularOnly(btHingeConstraintFloatData* c_this){
	return (int)(c_this->m_angularOnly);
}

float bullet_btHingeConstraintFloatData_GetFieldOfM_biasFactor(btHingeConstraintFloatData* c_this){
	return (float)(c_this->m_biasFactor);
}

int bullet_btHingeConstraintFloatData_GetFieldOfM_enableAngularMotor(btHingeConstraintFloatData* c_this){
	return (int)(c_this->m_enableAngularMotor);
}

float bullet_btHingeConstraintFloatData_GetFieldOfM_limitSoftness(btHingeConstraintFloatData* c_this){
	return (float)(c_this->m_limitSoftness);
}

float bullet_btHingeConstraintFloatData_GetFieldOfM_lowerLimit(btHingeConstraintFloatData* c_this){
	return (float)(c_this->m_lowerLimit);
}

float bullet_btHingeConstraintFloatData_GetFieldOfM_maxMotorImpulse(btHingeConstraintFloatData* c_this){
	return (float)(c_this->m_maxMotorImpulse);
}

float bullet_btHingeConstraintFloatData_GetFieldOfM_motorTargetVelocity(btHingeConstraintFloatData* c_this){
	return (float)(c_this->m_motorTargetVelocity);
}

btTransformFloatData* bullet_btHingeConstraintFloatData_GetFieldOfM_rbAFrame(btHingeConstraintFloatData* c_this){
	return (btTransformFloatData*)(&c_this->m_rbAFrame);
}

btTransformFloatData* bullet_btHingeConstraintFloatData_GetFieldOfM_rbBFrame(btHingeConstraintFloatData* c_this){
	return (btTransformFloatData*)(&c_this->m_rbBFrame);
}

float bullet_btHingeConstraintFloatData_GetFieldOfM_relaxationFactor(btHingeConstraintFloatData* c_this){
	return (float)(c_this->m_relaxationFactor);
}

btTypedConstraintData* bullet_btHingeConstraintFloatData_GetFieldOfM_typeConstraintData(btHingeConstraintFloatData* c_this){
	return (btTypedConstraintData*)(&c_this->m_typeConstraintData);
}

float bullet_btHingeConstraintFloatData_GetFieldOfM_upperLimit(btHingeConstraintFloatData* c_this){
	return (float)(c_this->m_upperLimit);
}

int bullet_btHingeConstraintFloatData_GetFieldOfM_useReferenceFrameA(btHingeConstraintFloatData* c_this){
	return (int)(c_this->m_useReferenceFrameA);
}

btHingeConstraintDoubleData2* bullet_NewbtHingeConstraintDoubleData2(){
	btHingeConstraintDoubleData2* wrap_out = new btHingeConstraintDoubleData2();
	return wrap_out;
}

int bullet_btHingeConstraintDoubleData2_GetFieldOfM_angularOnly(btHingeConstraintDoubleData2* c_this){
	return (int)(c_this->m_angularOnly);
}

double bullet_btHingeConstraintDoubleData2_GetFieldOfM_biasFactor(btHingeConstraintDoubleData2* c_this){
	return (double)(c_this->m_biasFactor);
}

int bullet_btHingeConstraintDoubleData2_GetFieldOfM_enableAngularMotor(btHingeConstraintDoubleData2* c_this){
	return (int)(c_this->m_enableAngularMotor);
}

double bullet_btHingeConstraintDoubleData2_GetFieldOfM_limitSoftness(btHingeConstraintDoubleData2* c_this){
	return (double)(c_this->m_limitSoftness);
}

double bullet_btHingeConstraintDoubleData2_GetFieldOfM_lowerLimit(btHingeConstraintDoubleData2* c_this){
	return (double)(c_this->m_lowerLimit);
}

double bullet_btHingeConstraintDoubleData2_GetFieldOfM_maxMotorImpulse(btHingeConstraintDoubleData2* c_this){
	return (double)(c_this->m_maxMotorImpulse);
}

double bullet_btHingeConstraintDoubleData2_GetFieldOfM_motorTargetVelocity(btHingeConstraintDoubleData2* c_this){
	return (double)(c_this->m_motorTargetVelocity);
}

char** bullet_btHingeConstraintDoubleData2_GetFieldOfM_padding1(btHingeConstraintDoubleData2* c_this){
	return (char**)(&c_this->m_padding1);
}

btTransformDoubleData* bullet_btHingeConstraintDoubleData2_GetFieldOfM_rbAFrame(btHingeConstraintDoubleData2* c_this){
	return (btTransformDoubleData*)(&c_this->m_rbAFrame);
}

btTransformDoubleData* bullet_btHingeConstraintDoubleData2_GetFieldOfM_rbBFrame(btHingeConstraintDoubleData2* c_this){
	return (btTransformDoubleData*)(&c_this->m_rbBFrame);
}

double bullet_btHingeConstraintDoubleData2_GetFieldOfM_relaxationFactor(btHingeConstraintDoubleData2* c_this){
	return (double)(c_this->m_relaxationFactor);
}

btTypedConstraintDoubleData* bullet_btHingeConstraintDoubleData2_GetFieldOfM_typeConstraintData(btHingeConstraintDoubleData2* c_this){
	return (btTypedConstraintDoubleData*)(&c_this->m_typeConstraintData);
}

double bullet_btHingeConstraintDoubleData2_GetFieldOfM_upperLimit(btHingeConstraintDoubleData2* c_this){
	return (double)(c_this->m_upperLimit);
}

int bullet_btHingeConstraintDoubleData2_GetFieldOfM_useReferenceFrameA(btHingeConstraintDoubleData2* c_this){
	return (int)(c_this->m_useReferenceFrameA);
}

btHingeConstraintDoubleData* bullet_NewbtHingeConstraintDoubleData(){
	btHingeConstraintDoubleData* wrap_out = new btHingeConstraintDoubleData();
	return wrap_out;
}

int bullet_btHingeConstraintDoubleData_GetFieldOfM_angularOnly(btHingeConstraintDoubleData* c_this){
	return (int)(c_this->m_angularOnly);
}

float bullet_btHingeConstraintDoubleData_GetFieldOfM_biasFactor(btHingeConstraintDoubleData* c_this){
	return (float)(c_this->m_biasFactor);
}

int bullet_btHingeConstraintDoubleData_GetFieldOfM_enableAngularMotor(btHingeConstraintDoubleData* c_this){
	return (int)(c_this->m_enableAngularMotor);
}

float bullet_btHingeConstraintDoubleData_GetFieldOfM_limitSoftness(btHingeConstraintDoubleData* c_this){
	return (float)(c_this->m_limitSoftness);
}

float bullet_btHingeConstraintDoubleData_GetFieldOfM_lowerLimit(btHingeConstraintDoubleData* c_this){
	return (float)(c_this->m_lowerLimit);
}

float bullet_btHingeConstraintDoubleData_GetFieldOfM_maxMotorImpulse(btHingeConstraintDoubleData* c_this){
	return (float)(c_this->m_maxMotorImpulse);
}

float bullet_btHingeConstraintDoubleData_GetFieldOfM_motorTargetVelocity(btHingeConstraintDoubleData* c_this){
	return (float)(c_this->m_motorTargetVelocity);
}

btTransformDoubleData* bullet_btHingeConstraintDoubleData_GetFieldOfM_rbAFrame(btHingeConstraintDoubleData* c_this){
	return (btTransformDoubleData*)(&c_this->m_rbAFrame);
}

btTransformDoubleData* bullet_btHingeConstraintDoubleData_GetFieldOfM_rbBFrame(btHingeConstraintDoubleData* c_this){
	return (btTransformDoubleData*)(&c_this->m_rbBFrame);
}

float bullet_btHingeConstraintDoubleData_GetFieldOfM_relaxationFactor(btHingeConstraintDoubleData* c_this){
	return (float)(c_this->m_relaxationFactor);
}

btTypedConstraintData* bullet_btHingeConstraintDoubleData_GetFieldOfM_typeConstraintData(btHingeConstraintDoubleData* c_this){
	return (btTypedConstraintData*)(&c_this->m_typeConstraintData);
}

float bullet_btHingeConstraintDoubleData_GetFieldOfM_upperLimit(btHingeConstraintDoubleData* c_this){
	return (float)(c_this->m_upperLimit);
}

int bullet_btHingeConstraintDoubleData_GetFieldOfM_useReferenceFrameA(btHingeConstraintDoubleData* c_this){
	return (int)(c_this->m_useReferenceFrameA);
}

btHingeConstraint* bullet_NewbtHingeConstraint(btRigidBody* rbA,btRigidBody* rbB,btVector3* pivotInA,btVector3* pivotInB,btVector3* axisInA,btVector3* axisInB,bool useReferenceFrameA){
	btRigidBody& c_arg_rbA=(btRigidBody&)(*rbA);
	btRigidBody& c_arg_rbB=(btRigidBody&)(*rbB);
	btVector3 const& c_arg_pivotInA=(btVector3 const&)(*pivotInA);
	btVector3 const& c_arg_pivotInB=(btVector3 const&)(*pivotInB);
	btVector3 const& c_arg_axisInA=(btVector3 const&)(*axisInA);
	btVector3 const& c_arg_axisInB=(btVector3 const&)(*axisInB);
	bool c_arg_useReferenceFrameA=useReferenceFrameA;
	btHingeConstraint* wrap_out = new btHingeConstraint(c_arg_rbA,c_arg_rbB,c_arg_pivotInA,c_arg_pivotInB,c_arg_axisInA,c_arg_axisInB,c_arg_useReferenceFrameA);
	return wrap_out;
}

btHingeConstraint* bullet_NewbtHingeConstraint1(btRigidBody* rbA,btVector3* pivotInA,btVector3* axisInA,bool useReferenceFrameA){
	btRigidBody& c_arg_rbA=(btRigidBody&)(*rbA);
	btVector3 const& c_arg_pivotInA=(btVector3 const&)(*pivotInA);
	btVector3 const& c_arg_axisInA=(btVector3 const&)(*axisInA);
	bool c_arg_useReferenceFrameA=useReferenceFrameA;
	btHingeConstraint* wrap_out = new btHingeConstraint(c_arg_rbA,c_arg_pivotInA,c_arg_axisInA,c_arg_useReferenceFrameA);
	return wrap_out;
}

btHingeConstraint* bullet_NewbtHingeConstraint2(btRigidBody* rbA,btRigidBody* rbB,btTransform* rbAFrame,btTransform* rbBFrame,bool useReferenceFrameA){
	btRigidBody& c_arg_rbA=(btRigidBody&)(*rbA);
	btRigidBody& c_arg_rbB=(btRigidBody&)(*rbB);
	btTransform const& c_arg_rbAFrame=(btTransform const&)(*rbAFrame);
	btTransform const& c_arg_rbBFrame=(btTransform const&)(*rbBFrame);
	bool c_arg_useReferenceFrameA=useReferenceFrameA;
	btHingeConstraint* wrap_out = new btHingeConstraint(c_arg_rbA,c_arg_rbB,c_arg_rbAFrame,c_arg_rbBFrame,c_arg_useReferenceFrameA);
	return wrap_out;
}

btHingeConstraint* bullet_NewbtHingeConstraint3(btRigidBody* rbA,btTransform* rbAFrame,bool useReferenceFrameA){
	btRigidBody& c_arg_rbA=(btRigidBody&)(*rbA);
	btTransform const& c_arg_rbAFrame=(btTransform const&)(*rbAFrame);
	bool c_arg_useReferenceFrameA=useReferenceFrameA;
	btHingeConstraint* wrap_out = new btHingeConstraint(c_arg_rbA,c_arg_rbAFrame,c_arg_useReferenceFrameA);
	return wrap_out;
}

void bullet_btHingeConstraint_enableAngularMotor(btHingeConstraint* c_this,bool enableMotor,double targetVelocity,double maxMotorImpulse){
	bool c_arg_enableMotor=enableMotor;
	btScalar c_arg_targetVelocity=targetVelocity;
	btScalar c_arg_maxMotorImpulse=maxMotorImpulse;
	c_this->enableAngularMotor(c_arg_enableMotor,c_arg_targetVelocity,c_arg_maxMotorImpulse);
}

void bullet_btHingeConstraint_enableMotor(btHingeConstraint* c_this,bool enableMotor){
	bool c_arg_enableMotor=enableMotor;
	c_this->enableMotor(c_arg_enableMotor);
}

btTransform* bullet_btHingeConstraint_getAFrame(btHingeConstraint* c_this){
	btTransform const& c_out = c_this->getAFrame();
	btTransform* wrap_out = (btTransform*)(&c_out);
	return wrap_out;
}

btTransform* bullet_btHingeConstraint_getAFrame1(btHingeConstraint* c_this){
	btTransform& c_out = c_this->getAFrame();
	btTransform* wrap_out = (btTransform*)(&c_out);
	return wrap_out;
}

bool bullet_btHingeConstraint_getAngularOnly(btHingeConstraint* c_this){
	bool c_out = c_this->getAngularOnly();
	bool wrap_out = (c_out);
	return wrap_out;
}

btTransform* bullet_btHingeConstraint_getBFrame(btHingeConstraint* c_this){
	btTransform const& c_out = c_this->getBFrame();
	btTransform* wrap_out = (btTransform*)(&c_out);
	return wrap_out;
}

btTransform* bullet_btHingeConstraint_getBFrame1(btHingeConstraint* c_this){
	btTransform& c_out = c_this->getBFrame();
	btTransform* wrap_out = (btTransform*)(&c_out);
	return wrap_out;
}

bool bullet_btHingeConstraint_getEnableAngularMotor(btHingeConstraint* c_this){
	bool c_out = c_this->getEnableAngularMotor();
	bool wrap_out = (c_out);
	return wrap_out;
}

btTransform* bullet_btHingeConstraint_getFrameOffsetA(btHingeConstraint* c_this){
	btTransform& c_out = c_this->getFrameOffsetA();
	btTransform* wrap_out = (btTransform*)(&c_out);
	return wrap_out;
}

btTransform* bullet_btHingeConstraint_getFrameOffsetB(btHingeConstraint* c_this){
	btTransform& c_out = c_this->getFrameOffsetB();
	btTransform* wrap_out = (btTransform*)(&c_out);
	return wrap_out;
}

double bullet_btHingeConstraint_getHingeAngle(btHingeConstraint* c_this){
	btScalar c_out = c_this->getHingeAngle();
	double wrap_out = (c_out);
	return wrap_out;
}

double bullet_btHingeConstraint_getHingeAngle1(btHingeConstraint* c_this,btTransform* transA,btTransform* transB){
	btTransform const& c_arg_transA=(btTransform const&)(*transA);
	btTransform const& c_arg_transB=(btTransform const&)(*transB);
	btScalar c_out = c_this->getHingeAngle(c_arg_transA,c_arg_transB);
	double wrap_out = (c_out);
	return wrap_out;
}

void bullet_btHingeConstraint_getInfo1NonVirtual(btHingeConstraint* c_this,btTypedConstraint::btConstraintInfo1* info){
	btTypedConstraint::btConstraintInfo1 * c_arg_info=(btTypedConstraint::btConstraintInfo1 *)(void*)(info);
	c_this->getInfo1NonVirtual(c_arg_info);
}

void bullet_btHingeConstraint_getInfo2Internal(btHingeConstraint* c_this,btTypedConstraint::btConstraintInfo2* info,btTransform* transA,btTransform* transB,btVector3* angVelA,btVector3* angVelB){
	btTypedConstraint::btConstraintInfo2 * c_arg_info=(btTypedConstraint::btConstraintInfo2 *)(void*)(info);
	btTransform const& c_arg_transA=(btTransform const&)(*transA);
	btTransform const& c_arg_transB=(btTransform const&)(*transB);
	btVector3 const& c_arg_angVelA=(btVector3 const&)(*angVelA);
	btVector3 const& c_arg_angVelB=(btVector3 const&)(*angVelB);
	c_this->getInfo2Internal(c_arg_info,c_arg_transA,c_arg_transB,c_arg_angVelA,c_arg_angVelB);
}

void bullet_btHingeConstraint_getInfo2InternalUsingFrameOffset(btHingeConstraint* c_this,btTypedConstraint::btConstraintInfo2* info,btTransform* transA,btTransform* transB,btVector3* angVelA,btVector3* angVelB){
	btTypedConstraint::btConstraintInfo2 * c_arg_info=(btTypedConstraint::btConstraintInfo2 *)(void*)(info);
	btTransform const& c_arg_transA=(btTransform const&)(*transA);
	btTransform const& c_arg_transB=(btTransform const&)(*transB);
	btVector3 const& c_arg_angVelA=(btVector3 const&)(*angVelA);
	btVector3 const& c_arg_angVelB=(btVector3 const&)(*angVelB);
	c_this->getInfo2InternalUsingFrameOffset(c_arg_info,c_arg_transA,c_arg_transB,c_arg_angVelA,c_arg_angVelB);
}

void bullet_btHingeConstraint_getInfo2NonVirtual(btHingeConstraint* c_this,btTypedConstraint::btConstraintInfo2* info,btTransform* transA,btTransform* transB,btVector3* angVelA,btVector3* angVelB){
	btTypedConstraint::btConstraintInfo2 * c_arg_info=(btTypedConstraint::btConstraintInfo2 *)(void*)(info);
	btTransform const& c_arg_transA=(btTransform const&)(*transA);
	btTransform const& c_arg_transB=(btTransform const&)(*transB);
	btVector3 const& c_arg_angVelA=(btVector3 const&)(*angVelA);
	btVector3 const& c_arg_angVelB=(btVector3 const&)(*angVelB);
	c_this->getInfo2NonVirtual(c_arg_info,c_arg_transA,c_arg_transB,c_arg_angVelA,c_arg_angVelB);
}

double bullet_btHingeConstraint_getLimitBiasFactor(btHingeConstraint* c_this){
	btScalar c_out = c_this->getLimitBiasFactor();
	double wrap_out = (c_out);
	return wrap_out;
}

double bullet_btHingeConstraint_getLimitRelaxationFactor(btHingeConstraint* c_this){
	btScalar c_out = c_this->getLimitRelaxationFactor();
	double wrap_out = (c_out);
	return wrap_out;
}

double bullet_btHingeConstraint_getLimitSign(btHingeConstraint* c_this){
	btScalar c_out = c_this->getLimitSign();
	double wrap_out = (c_out);
	return wrap_out;
}

double bullet_btHingeConstraint_getLimitSoftness(btHingeConstraint* c_this){
	btScalar c_out = c_this->getLimitSoftness();
	double wrap_out = (c_out);
	return wrap_out;
}

double bullet_btHingeConstraint_getLowerLimit(btHingeConstraint* c_this){
	btScalar c_out = c_this->getLowerLimit();
	double wrap_out = (c_out);
	return wrap_out;
}

double bullet_btHingeConstraint_getMaxMotorImpulse(btHingeConstraint* c_this){
	btScalar c_out = c_this->getMaxMotorImpulse();
	double wrap_out = (c_out);
	return wrap_out;
}

double bullet_btHingeConstraint_getMotorTargetVelocity(btHingeConstraint* c_this){
	btScalar c_out = c_this->getMotorTargetVelocity();
	double wrap_out = (c_out);
	return wrap_out;
}

int bullet_btHingeConstraint_getSolveLimit(btHingeConstraint* c_this){
	int c_out = c_this->getSolveLimit();
	int wrap_out = (c_out);
	return wrap_out;
}

double bullet_btHingeConstraint_getUpperLimit(btHingeConstraint* c_this){
	btScalar c_out = c_this->getUpperLimit();
	double wrap_out = (c_out);
	return wrap_out;
}

bool bullet_btHingeConstraint_getUseFrameOffset(btHingeConstraint* c_this){
	bool c_out = c_this->getUseFrameOffset();
	bool wrap_out = (c_out);
	return wrap_out;
}

bool bullet_btHingeConstraint_getUseReferenceFrameA(btHingeConstraint* c_this){
	bool c_out = c_this->getUseReferenceFrameA();
	bool wrap_out = (c_out);
	return wrap_out;
}

bool bullet_btHingeConstraint_hasLimit(btHingeConstraint* c_this){
	bool c_out = c_this->hasLimit();
	bool wrap_out = (c_out);
	return wrap_out;
}

void bullet_btHingeConstraint_setAngularOnly(btHingeConstraint* c_this,bool angularOnly){
	bool c_arg_angularOnly=angularOnly;
	c_this->setAngularOnly(c_arg_angularOnly);
}

void bullet_btHingeConstraint_setAxis(btHingeConstraint* c_this,btVector3* axisInA){
	btVector3& c_arg_axisInA=(btVector3&)(*axisInA);
	c_this->setAxis(c_arg_axisInA);
}

void bullet_btHingeConstraint_setFrames(btHingeConstraint* c_this,btTransform* frameA,btTransform* frameB){
	btTransform const& c_arg_frameA=(btTransform const&)(*frameA);
	btTransform const& c_arg_frameB=(btTransform const&)(*frameB);
	c_this->setFrames(c_arg_frameA,c_arg_frameB);
}

void bullet_btHingeConstraint_setLimit(btHingeConstraint* c_this,double low,double high,double _softness,double _biasFactor,double _relaxationFactor){
	btScalar c_arg_low=low;
	btScalar c_arg_high=high;
	btScalar c_arg__softness=_softness;
	btScalar c_arg__biasFactor=_biasFactor;
	btScalar c_arg__relaxationFactor=_relaxationFactor;
	c_this->setLimit(c_arg_low,c_arg_high,c_arg__softness,c_arg__biasFactor,c_arg__relaxationFactor);
}

void bullet_btHingeConstraint_setMaxMotorImpulse(btHingeConstraint* c_this,double maxMotorImpulse){
	btScalar c_arg_maxMotorImpulse=maxMotorImpulse;
	c_this->setMaxMotorImpulse(c_arg_maxMotorImpulse);
}

void bullet_btHingeConstraint_setMotorTarget(btHingeConstraint* c_this,btQuaternion* qAinB,double dt){
	btQuaternion const& c_arg_qAinB=(btQuaternion const&)(*qAinB);
	btScalar c_arg_dt=dt;
	c_this->setMotorTarget(c_arg_qAinB,c_arg_dt);
}

void bullet_btHingeConstraint_setMotorTarget1(btHingeConstraint* c_this,double targetAngle,double dt){
	btScalar c_arg_targetAngle=targetAngle;
	btScalar c_arg_dt=dt;
	c_this->setMotorTarget(c_arg_targetAngle,c_arg_dt);
}

void bullet_btHingeConstraint_setMotorTargetVelocity(btHingeConstraint* c_this,double motorTargetVelocity){
	btScalar c_arg_motorTargetVelocity=motorTargetVelocity;
	c_this->setMotorTargetVelocity(c_arg_motorTargetVelocity);
}

void bullet_btHingeConstraint_setUseFrameOffset(btHingeConstraint* c_this,bool frameOffsetOnOff){
	bool c_arg_frameOffsetOnOff=frameOffsetOnOff;
	c_this->setUseFrameOffset(c_arg_frameOffsetOnOff);
}

void bullet_btHingeConstraint_setUseReferenceFrameA(btHingeConstraint* c_this,bool useReferenceFrameA){
	bool c_arg_useReferenceFrameA=useReferenceFrameA;
	c_this->setUseReferenceFrameA(c_arg_useReferenceFrameA);
}

void bullet_btHingeConstraint_testLimit(btHingeConstraint* c_this,btTransform* transA,btTransform* transB){
	btTransform const& c_arg_transA=(btTransform const&)(*transA);
	btTransform const& c_arg_transB=(btTransform const&)(*transB);
	c_this->testLimit(c_arg_transA,c_arg_transB);
}

void bullet_btHingeConstraint_updateRHS(btHingeConstraint* c_this,double timeStep){
	btScalar c_arg_timeStep=timeStep;
	c_this->updateRHS(c_arg_timeStep);
}

btHingeAccumulatedAngleConstraint* bullet_NewbtHingeAccumulatedAngleConstraint(btRigidBody* rbA,btRigidBody* rbB,btVector3* pivotInA,btVector3* pivotInB,btVector3* axisInA,btVector3* axisInB,bool useReferenceFrameA){
	btRigidBody& c_arg_rbA=(btRigidBody&)(*rbA);
	btRigidBody& c_arg_rbB=(btRigidBody&)(*rbB);
	btVector3 const& c_arg_pivotInA=(btVector3 const&)(*pivotInA);
	btVector3 const& c_arg_pivotInB=(btVector3 const&)(*pivotInB);
	btVector3 const& c_arg_axisInA=(btVector3 const&)(*axisInA);
	btVector3 const& c_arg_axisInB=(btVector3 const&)(*axisInB);
	bool c_arg_useReferenceFrameA=useReferenceFrameA;
	btHingeAccumulatedAngleConstraint* wrap_out = new btHingeAccumulatedAngleConstraint(c_arg_rbA,c_arg_rbB,c_arg_pivotInA,c_arg_pivotInB,c_arg_axisInA,c_arg_axisInB,c_arg_useReferenceFrameA);
	return wrap_out;
}

btHingeAccumulatedAngleConstraint* bullet_NewbtHingeAccumulatedAngleConstraint1(btRigidBody* rbA,btVector3* pivotInA,btVector3* axisInA,bool useReferenceFrameA){
	btRigidBody& c_arg_rbA=(btRigidBody&)(*rbA);
	btVector3 const& c_arg_pivotInA=(btVector3 const&)(*pivotInA);
	btVector3 const& c_arg_axisInA=(btVector3 const&)(*axisInA);
	bool c_arg_useReferenceFrameA=useReferenceFrameA;
	btHingeAccumulatedAngleConstraint* wrap_out = new btHingeAccumulatedAngleConstraint(c_arg_rbA,c_arg_pivotInA,c_arg_axisInA,c_arg_useReferenceFrameA);
	return wrap_out;
}

btHingeAccumulatedAngleConstraint* bullet_NewbtHingeAccumulatedAngleConstraint2(btRigidBody* rbA,btRigidBody* rbB,btTransform* rbAFrame,btTransform* rbBFrame,bool useReferenceFrameA){
	btRigidBody& c_arg_rbA=(btRigidBody&)(*rbA);
	btRigidBody& c_arg_rbB=(btRigidBody&)(*rbB);
	btTransform const& c_arg_rbAFrame=(btTransform const&)(*rbAFrame);
	btTransform const& c_arg_rbBFrame=(btTransform const&)(*rbBFrame);
	bool c_arg_useReferenceFrameA=useReferenceFrameA;
	btHingeAccumulatedAngleConstraint* wrap_out = new btHingeAccumulatedAngleConstraint(c_arg_rbA,c_arg_rbB,c_arg_rbAFrame,c_arg_rbBFrame,c_arg_useReferenceFrameA);
	return wrap_out;
}

btHingeAccumulatedAngleConstraint* bullet_NewbtHingeAccumulatedAngleConstraint3(btRigidBody* rbA,btTransform* rbAFrame,bool useReferenceFrameA){
	btRigidBody& c_arg_rbA=(btRigidBody&)(*rbA);
	btTransform const& c_arg_rbAFrame=(btTransform const&)(*rbAFrame);
	bool c_arg_useReferenceFrameA=useReferenceFrameA;
	btHingeAccumulatedAngleConstraint* wrap_out = new btHingeAccumulatedAngleConstraint(c_arg_rbA,c_arg_rbAFrame,c_arg_useReferenceFrameA);
	return wrap_out;
}

double bullet_btHingeAccumulatedAngleConstraint_getAccumulatedHingeAngle(btHingeAccumulatedAngleConstraint* c_this){
	btScalar c_out = c_this->getAccumulatedHingeAngle();
	double wrap_out = (c_out);
	return wrap_out;
}

void bullet_btHingeAccumulatedAngleConstraint_setAccumulatedHingeAngle(btHingeAccumulatedAngleConstraint* c_this,double accAngle){
	btScalar c_arg_accAngle=accAngle;
	c_this->setAccumulatedHingeAngle(c_arg_accAngle);
}

#ifdef __cplusplus
}
#endif
